Imagens de Cliente

void cdGetImageRGB(unsigned char *r, unsigned char *g, unsigned char *b, int x, int y, int w, int h); [em C]
cdGetImageRGB(imagergb: imagergb_tag; x, y: number) [em Lua]

Fornece como retorno os componentes vermelho, verde e azul de cada pixel de uma imagem de servidor. Os componentes RGB são dados em três matrizes armazenadas como arrays de bytes. O componente (i,j) dessas matrizes encontra-se no endereço (j*w+i). Como ocorre com todas as primitivas da biblioteca Canvas Draw, o pixel (0,0) fica no canto inferior esquerdo e o pixel (w-1,h-1) fica no canto superior direito do retângulo da imagem.

void cdPutImageRectRGB(int iw, int ih, unsigned char *r, unsigned char *g, unsigned char *b, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax); [em C]
void wdPutImageRectRGB(int iw, int ih, unsigned char *r, unsigned char *g, unsigned char *b, double x, double y, double w, double h, int xmin, int xmax, int ymin, int ymax); (WC) [em C]
cdPutImageRectRGB(imagergb: imagergb_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) [em Lua]
wdPutImageRectRGB(imagergb: imagergb_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [em Lua]

Põe, em uma área especificada do canvas, uma imagem que tem os componentes vermelho, verde e azul definidos nas três matrizes. Estas são armazenadas em arrays de bytes. O componente (i,j) dessas matrizes encontra-se no endereço (j*iw+i). Como ocorre com todas as primitivas da biblioteca CD, o pixel (0,0) fica no canto inferior esquerdo e o pixel (iw-1,ih-1) fica no canto superior direito do retângulo da imagem. Os parâmetros w e h referem-se ao retângulo-destino do canvas, de forma que é possível reduzir ou expandir a imagem desenhada.Permite especificar um retângulo na imagem para ser desenhado. Se xmin, xmax, ymin e ymax forem 0 então assume-se a imagem toda. Se w e h forem 0 assume-se o tamanho da imagem (iw e ih). Se o driver possuir bpp <=8, ou apenas 256 cores ou menos, a imagem é convertida para 256 cores otimas usando a função cdRGB2Map e desenhada usando cdPutImageRectMap.

void cdPutImageRectRGBA(int iw, int ih, unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax); [em C]
void wdPutImageRectRGBA(int iw, int ih, unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a, double x, double y, double w, double h, int xmin, int xmax, int ymin, int ymax); (WC) [em C]
cdPutImageRectRGBA(imagergba: imagergba_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) [em Lua]
wdPutImageRectRGBA(imagergba: imagergba_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [em Lua]

É o mesmo que a função cdPutImageRectRGB, exceto pelo fato de que é possível especificar um canal alfa. A cor resultante é a cor da imagem pesada pelo valor alfa empregando-se a fórmula result=(source * alpha + destine * (255 - alpha)) / 255. Isto significa que, se alfa for 0, a cor resultante é a cor de destino (completamente transparente) e, se alfa for 255, a cor resultante é a cor original da imagem (completamente opaca).

Se esta função não é definida para o driver ou se alpha é NULL, a função cdPutImageRGB é usada, caso esteja definida.

void cdPutImageRectMap(int iw, int ih, unsigned char *index, long int *colors, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax); [em C]
void wdPutImageRectMap(int iw, int ih, unsigned char *index, long int *colors, double x, double y, double w, double h, int xmin, int xmax, int ymin, int ymax); (WC) [em C]
cdPutImageRectMap(imagemap: imagemap_tag; palette: palette_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) [em Lua]
wdPutImageRectMap(imagemap: imagemap_tag; palette: palette_tag; x, y, w, h, xmin, xmax, ymin, ymax: number) (WC) [em Lua]

É o mesmo que a função cdPutImageRectRGB, exceto pelo fato de que as cores são dadas através de uma matriz de índices (mapa). A cor correspondente a um dado índice é dada em colors[index]. O mapa é também uma matriz armazenada como um vetor de bytes. Se o vetor de cores for nulo, assume-se um vetor com 256 tons de cinza.

void cdRGB2Map(int width, int height, unsigned char *red, unsigned char *green, unsigned char *blue, unsigned char *map, int pal_size, long *color); [em C]
cdRGB2Map(imagergb: imagergb_tag, imagemap: imagemap_tag) [em Lua]

Converte uma imagem RGB em uma imagem de 256 cores indexadas. A imagem resultante deve ter o mesmo tamanho (largura x comprimento) que a imagem RGB. É necessário alocar memória para os arrays map e colors. É o mesmo algoritmo que o utilizado na biblioteca IM. De fato, é o mesmo código.


Imagens de Servidor

void* cdCreateImage(int w, int h); [em C]
cdCreateImage(w, h: number) -> (image: image_tag) [em Lua]

Cria uma imagem compatível na memória do servidor com wxh pixels. Uma imagem compatível tem a mesma representação de cores (o número de bits por pixel) que o canvas do servidor. Você só deve usar a imagem de servidor com um canvas ativo do mesmo tipo que o canvas ativo de quando a imagem foi criada. O fundo padrão é o mesmo para o canvas, CD_WHITE. As funções de images de servidor são em geral mais eficientes que as funções de imagens cliente.

void cdKillImage(void *image); [em C]
cdKillImage(image: image_tag) [em Lua]

Libera a memória alocada para a imagem. Não é necessário um canvas ativo para chamar esta função.

void cdGetImage(void *image, int x, int y); [em C]
cdGetImage(image: image_tag; x, y: number) [em Lua]

Copia uma região retangular do contexto ativo corrente para a memória (image). (x,y) é a coordenada do canto inferior esquerdo da região retangular. A largura e o comprimento da região retangular são definidos na estrutura da imagem (quando esta é criada).

void cdPutImageRect(void *image, int x, int y, int xmin, int xmax, int ymin, int ymax); [em C]
void wdPutImageRect(void* image, double x, double y, int xmin, int xmax, int ymin, int ymax); (WC) [em C]
cdPutImageRect(image: image_tag; x, y, xmin, xmax, ymin, ymax: number) [em Lua]
wdPutImageRect(image: image_tag; x, y, xmin, xmax, ymin, ymax: number) (WC) [em Lua]

Copia uma imagem em uma região retangular do canvas com o canto inferior esquerdo em (x,y). Permite especificar um retângulo na imagem para ser desenhado. Se xmin, xmax, ymin e ymax forem 0 então assume-se a imagem toda.

void cdScrollArea(int xmin, int xmax, int ymin, int ymax, int dx, int dy); [em C]
cdScrollArea(xmin, xmax, ymin, ymax, dx, dy: number) [em Lua]

Copia o retângulo definido pelas coordenadas (xmin,ymin) e (xmax,ymax) no retângulo definido por (xmin+dx,ymin+dy) e (xmax+dx,ymax+dy). Tem o mesmo efeito que cdGetImage seguido por cdPutImage, porém deve ser mais rápido e não precisa da criação explícita de uma imagem para ser realizada. Note que a região que pertence ao primeiro retângulo mas não ao segundo, permanece inalterada (a função não limpa esta região).


Funções Auxiliares para Imagens

As funções a seguir servem apenas para encapsular os vários tipos de imagem da biblioteca em uma única estrutura, simplificando seu tratamento.

Para isso foi criada uma estrutura pública chamada cdImageEx que armazenará a imagem. Desta estrutura os seguintes campos são oficialmente definidos:

cdImageEx
  int w;      /* largura da imagem */
  int h;      /* altura da imagem */
  int type;   /* tipo da imagem: CD_SERVER, CD_RGBA, CD_RGB ou CD_MAP(256) */

cdImageEx* cdCreateImageEx(int w, int h, int type); [em C]
cdCreateImageEx(w, h, type: number) -> (image: imageex_tag) [em Lua]

Cria uma imagem com w de largura e h de altura e do tipo type. O tipo pode ser CD_SERVER, CD_RGBA, CD_RGB ou CD_MAP. Mas CD_MAP apenas significa que a imagem MAP terá 256 cores, se type for maior que 0 assume-se que a imagem será MAP com número de cores na palheta igual a type. Internamente a palheta de cores é alocada sempre com 256 entradas que podem ser completamente preenchidas ou não. Neste caso, o valor de type pode ser modificado se desejado. Também encapsula a cdCreateImage.

cdImageEx* cdCreateImageDataEx(int w, int h, int type, ...); [em C]
[Não existe equivalente em Lua]

Semelhante a cdCreateImageEx, mas aceita a área de dados já alocada pelo usuário. Os parâmetros variam de acordo com o tipo de imagem.

CD_SERVER - (void* image)
CD_RGBA - (unsigned char* red, unsigned char* green, unsigned char* blue, unsigned char* alpha)
CD_RGB - (unsigned char* red, unsigned char* green, unsigned char* blue)
CD_MAP - (unsigned char* index, lont int* colors)

void cdKillImageEx(cdImageEx* image); [em C]
cdKillImageEx(image: imageex_tag) [em Lua]

Libera a memória alocada para a imagem. Não é necessário um canvas ativo para chamar esta função. Também encapsula a cdKillImage.

unsigned char* cdImageDataEx(cdImageEx* image, int dataptr); [em C]
cdImageDataEx(image: imageex_tag; dataptr: number) [em Lua]

Retorna um ponteiro para a área de dados da imagem de acordo com dataptr. Os seguintes valores são definidos para dataptr:

CD_IRED - componente de vermelho de uma imagem RGB.
CD_IGREEN - componente de verde de uma imagem RGB.
CD_IBLUE - componente de azul de uma imagem RGB.
CD_IALPHA - componente alfa de uma imagem RGBA.
CD_INDEX - índices de uma imagem MAP.
CD_COLORS - tabela de cores de uma imagem MAP. Neste caso deve-se realizar uma conversão de tipo para (long int*).
CD_ISERVER - imagem de servidor.

void cdImageRectEx(cdImageEx* image, int xmin, int xmax, int ymin, int ymax); [em C]
cdImageRectEx(image: imageex_tag; xmin, xmax, ymin, ymax: number) [em Lua]

Permite especificar uma região de interesse para ser usada pela função cdPutImageEx. Se nenhuma região foi definida a imagem toda é usada, ou seja (0, w-1, 0, h-1).

void cdPutImageEx(cdImageEx* image, int x, int y, int w, int h); [em C]
void wdPutImageEx(cdImageEx* image, double x, double y, double w, double h); (WC) [em C]
cdPutImageEx(image: imageex_tag; x, y, w, h: number) [em Lua]
wdPutImageEx(image: imageex_tag; x, y, w, h: number) (WC) [em Lua]

Desenha a imagem na posição (x,y) com mudança de escala. Encapsula cdPutImageRect, cdPutImageRectRGB, cdPutImageRectRGBA e cdPutImageRectMap. Para imagens de servidor w e h são ignorados. A região da imagem desenhada depende do retângulo definido pela cdImageRectEx, se nenhum foi definido a imagem toda é usada.

Os parâmetros w e h permitem distorcer a imagem, aumentando ou diminuindo suas dimensões, ao ser desenhada. Se w e/ou h forem 0 então assume-se que não haverá mudança de escala. Esses parâmetros são ignorados para imagens de servidor.

void cdGetImageEx(cdImageEx* image, int x, int y); [em C]
cdGetImageEx(image: imageex_tag; x, y: number) [em Lua]

Encapsula cdGetImageRGB e cdGetImage. Não faz nada se a imagem for MAP.

void cdRGB2MapEx(cdImageEx* image_rgb, cdImageEx* image_map); [em C]
cdRGB2MapEx(image_rgb: imageex_tag, image_map: imageex_tag) [em Lua]

Encapsula cdRGB2Map. As imagens devem ser dos tipos RGB(A), e MAP, respectivamente.